﻿using AiFrame.InterfaceLib.Data.Patterns;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;

namespace InterfaceLib.Tests
{
    
    
    /// <summary>
    ///Dies ist eine Testklasse für "ObservableListTest" und soll
    ///alle ObservableListTest Komponententests enthalten.
    ///</summary>
    [TestClass()]
    public class ObservableListTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Ruft den Testkontext auf, der Informationen
        ///über und Funktionalität für den aktuellen Testlauf bietet, oder legt diesen fest.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Zusätzliche Testattribute
        // 
        //Sie können beim Verfassen Ihrer Tests die folgenden zusätzlichen Attribute verwenden:
        //
        //Mit ClassInitialize führen Sie Code aus, bevor Sie den ersten Test in der Klasse ausführen.
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Mit ClassCleanup führen Sie Code aus, nachdem alle Tests in einer Klasse ausgeführt wurden.
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Mit TestInitialize können Sie vor jedem einzelnen Test Code ausführen.
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Mit TestCleanup können Sie nach jedem einzelnen Test Code ausführen.
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///Ein Test für "ObservableList`1-Konstruktor"
        ///</summary>
        public void ObservableListConstructorTestHelper<T>()
        {
            ObservableList<T> target = new ObservableList<T>();
            Assert.IsNotNull(target);
        }

        [TestMethod()]
        public void ObservableListConstructorTest()
        {
            ObservableListConstructorTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "Add"
        ///</summary>
        public void AddTestHelper<T>()
        {
            ObservableList<T> target = new ObservableList<T>();
            T item = default(T);
            target.Add(item);

            Assert.IsTrue(target.Contains(item));
        }

        [TestMethod()]
        public void AddTest()
        {
            AddTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "Clear"
        ///</summary>
        public void ClearTestHelper<T>()
        {
            ObservableList<T> target = new ObservableList<T>();
            target.Add(default(T));
            target.Add(default(T));

            Assert.AreEqual(2, target.Count);
            target.Clear();
            Assert.AreEqual(0, target.Count);

        }

        [TestMethod()]
        public void ClearTest()
        {
            ClearTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "Insert"
        ///</summary>
        public void InsertTestHelper<T>() where T : new()
        {
            ObservableList<T> target = new ObservableList<T>();
            int index = 0;
            T item = new T();
            target.Insert(index, item);
            
            Assert.AreEqual(0, target.IndexOf(item));
        }

        [TestMethod()]
        public void InsertTest()
        {
            InsertTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "Remove"
        ///</summary>
        public void RemoveTestHelper<T>() where T : new()
        {
            ObservableList<T> target = new ObservableList<T>();
            T item = new T();
            target.Add(item);

            Assert.IsTrue(target.Contains(item));

            target.Remove(item);
            Assert.IsFalse(target.Contains(item));
        }

        [TestMethod()]
        public void RemoveTest()
        {
            RemoveTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "RemoveAt"
        ///</summary>
        public void RemoveAtTestHelper<T>() where T : new()
        {
            ObservableList<T> target = new ObservableList<T>();
            T item = new T();
            target.Add(item);

            Assert.AreEqual(1, target.Count);

            target.RemoveAt(0);

            Assert.AreEqual(0, target.Count);
        }

        [TestMethod()]
        public void RemoveAtTest()
        {
            RemoveAtTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///Ein Test für "Sort"
        ///</summary>
        public void SortTest1Helper<T>() where T : new()
        {
            ObservableList<T> target = new ObservableList<T>();

            T item1 = new T();
            T item2 = new T();

            target.Add(item1);
            target.Add(item2);

            Comparison<T> comparison = new Comparison<T>((t1, t2) => 0);
            target.Sort(comparison);
            
            Assert.AreEqual(item2, target[0]);

        }

        [TestMethod()]
        public void SortTest1()
        {
            SortTest1Helper<GenericParameterHelper>();
        }
    }
}
